﻿#region Código Gerado Pela Fábrica de Software (Using)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using itau.im.entidade;
using EnterpriseLibraryWrapper;
using System.Data;
#endregion

#region Código Gerado Pela Fábrica de Software (Namespace)
namespace itau.im.dado
{
    #region Código Gerado Pela Fábrica de Software (Classe)

    public class ProdutoFinanceiroDB : IProdutoFinanceiroDAO
    {
        #region Código Gerado Pela Fábrica de Software (Métodos)

        public ProdutoFinanceiro ObterArvoreProdutoDerivado(int codigoProdutoDerivado)
        {
            IDataAccessWrapper data = null;
            DataSet ds = null;
            ProdutoFinanceiro produto = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();
                
                data.ParameterIn.Add(new ParameterInWrapper("COD_PROD_FINN_DRV", codigoProdutoDerivado, DbType.Int32));

                data.ParameterOut.Add(new ParameterOutWrapper("NOM_PROD_FINN_DRV", DbType.String, 50));
                data.ParameterOut.Add(new ParameterOutWrapper("COD_PROD_FINN", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("NOM_PROD_FINN", DbType.String, 50));
                data.ParameterOut.Add(new ParameterOutWrapper("COD_FAMI_PROD", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("NOM_FAMI_PROD", DbType.String, 50));
                data.ParameterOut.Add(new ParameterOutWrapper("COD_CLAS_PROD", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("NOM_CLAS_PROD", DbType.String, 50));

                ds = data.ExecuteParameterToDataSet("DB2IM.IM0S8C");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    produto = EntidadeFactory.getArvoreProdutoDerivado(ds.Tables[0].Rows[0]);
                }
                
                return produto;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
                ds.Dispose();
                ds = null;
                produto = null;
            }

            return new ProdutoFinanceiro();
        }

        public IList<FamiliaProdutoFinanceiro> ObterFamiliasProdutoFinanceiroPorCodigoClasseProduto(int codigoClasseProduto)
        {
            List<FamiliaProdutoFinanceiro> lista = new List<FamiliaProdutoFinanceiro>();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CLAS_PROD", codigoClasseProduto, DbType.Int32));

                ds = data.ExecuteDataSet("DB2IM.IMSJ6");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getFamiliaProdutoFinanceiro(linha));
                    }
                }

                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                lista = null;
                data.Dispose();
                data = null;
                ds = null;
            }

            return new List<FamiliaProdutoFinanceiro>();
        }

        public void AtualizarFamiliaProdutoFinanceiro(FamiliaProdutoFinanceiro familiaProdutoFinanceiro)
        {
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_FAMI_PROD", familiaProdutoFinanceiro.CodigoFamiliaProduto, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_FAMI_PROD", familiaProdutoFinanceiro.NomeFamiliaProduto, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CLAS_PROD", familiaProdutoFinanceiro.CodigoClasseProduto, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@DES_FAMI", familiaProdutoFinanceiro.DescricaoFamilia, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CORO_PROD_FIN", familiaProdutoFinanceiro.CodigoCorporativoProdutoFinanceiro, DbType.String));

                data.ParameterIn.Add(new ParameterInWrapper("@IND_RGTO_ATIV", 1, DbType.Int16));

                data.ExecuteNonQuery("DB2IM.IMSJ8");

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }
        }

        public IList<ProdutoFinanceiro> ObterProdutosFinanceiros()
        {
            List<ProdutoFinanceiro> lista = new List<ProdutoFinanceiro>();
            IDataAccessWrapper data = null;
            DataSet ds;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                ds = data.ExecuteDataSet("DB2IM.IMSEI");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getProdutoFinanceiro(linha));
                    }
                }

                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                lista = null;
                data.Dispose();
                data = null;
                ds = null;
            }

            return new List<ProdutoFinanceiro>();
        }

        public void CriarClasseProdutoFinanceiro(ClasseProdutoFinanceiro classeProduto)
        {
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@NOM_CLAS_PROD",
                                                            classeProduto.NomeClasseProduto,
                                                            DbType.String));

                data.ParameterIn.Add(new ParameterInWrapper("@DES_CLAS",
                                                            classeProduto.DescricaoClasse,
                                                            DbType.String));

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CORO",
                                                            classeProduto.CodigoCorporativo,
                                                            DbType.String));

                data.ExecuteNonQuery("DB2IM.IMSKH");

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }
        }

        public void ExcluirClasseProdutoFinanceiro(int codigoClasse)
        {
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CLAS_PROD",
                                                            codigoClasse,
                                                            DbType.Int32));
                data.ExecuteNonQuery("DB2IM.IMSJ4");
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }
        }

        public List<ProdutoFinanceiro> ObterProdutoFinanceiroPorCodigoFamiliaProduto(int codigoFamilia)
        {
            List<ProdutoFinanceiro> lista = null;
            IDataAccessWrapper data = null;
            DataSet ds = null;

            try
            {
                lista = new List<ProdutoFinanceiro>();

                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_FAMI_PROD", codigoFamilia, DbType.Int32));

                ds = data.ExecuteDataSet("DB2IM.IMSJA");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getProdutoFinanceiro(linha));
                    }
                }

                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                lista = null;
                ds = null;
                data.Dispose();
                data = null;
            }

            return new List<ProdutoFinanceiro>();
        }

        public FamiliaProdutoFinanceiro ObterFamiliaProdutoFinanceiro(int codigoFamilia)
        {
            FamiliaProdutoFinanceiro familiaProdutoFinanceiro = null;
            IDataAccessWrapper data = null;
            DataRow dr = null;

            try
            {
                familiaProdutoFinanceiro = new FamiliaProdutoFinanceiro();

                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_FAMI_PROD", codigoFamilia, DbType.Int32));
                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_FAMI_PROD", DbType.String, 50));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CLAS_PROD", DbType.Int32, 4));
                data.ParameterOut.Add(new ParameterOutWrapper("@DES_FAMI", DbType.String, 100));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CORO_PROD_FINN", DbType.String, 15));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_RGTO_ATIV", DbType.Int16, 2));

                dr = data.ExecuteParameterToDataSet("DB2IM.IMSJ7").Tables[0].Rows[0];

                familiaProdutoFinanceiro = EntidadeFactory.getFamiliaProdutoFinanceiro(dr);

                return familiaProdutoFinanceiro;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                familiaProdutoFinanceiro = null;
                data.Dispose();
                data = null;
                dr = null;
            }

            return new FamiliaProdutoFinanceiro();
        }

        public IList<ClasseProdutoFinanceiro> ObterClassesProdutoFinanceiro()
        {
            List<ClasseProdutoFinanceiro> lista = null;
            IDataAccessWrapper data = null;
            DataSet ds = null;

            try
            {
                lista = new List<ClasseProdutoFinanceiro>();

                data = EnterpriseLibraryFactory.GetDataAccess();

                ds = data.ExecuteDataSet("DB2IM.IMSEG");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        lista.Add(EntidadeFactory.getClasseProdutoFinanceiro(linha));
                    }
                }

                return lista;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                lista = null;
                data.Dispose();
                data = null;
                ds = null;
            }

            return new List<ClasseProdutoFinanceiro>();
        }

        public void CriarFamiliaProdutoFinanceiro(FamiliaProdutoFinanceiro familiaProdutoFinanceiro)
        {
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@NOM_FAMI_PROD", familiaProdutoFinanceiro.NomeFamiliaProduto, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CLAS_PROD", familiaProdutoFinanceiro.CodigoClasseProduto, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@DES_FAMI", familiaProdutoFinanceiro.DescricaoFamilia, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CORO_PROD_FIN", familiaProdutoFinanceiro.CodigoCorporativoProdutoFinanceiro, DbType.String));

                data.ExecuteNonQuery("DB2IM.IMSKE");
            }

            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }
        }

        public void ExcluirFamiliaProdutoFinanceiro(int codigoFamilia)
        {
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_FAMI_PROD", codigoFamilia, DbType.Int32));

                data.ExecuteNonQuery("DB2IM.IMSJ9");
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }
        }

        public ClasseProdutoFinanceiro ObterClasseProdutoFinanceiro(int codigoClasse)
        {
            ClasseProdutoFinanceiro classeProdutoFinanceiro = null;
            IDataAccessWrapper data = null;
            DataRow dr = null;

            try
            {
                classeProdutoFinanceiro = new ClasseProdutoFinanceiro();

                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CLAS_PROD", codigoClasse, DbType.Int32));

                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_CLAS_PROD", DbType.String, 50));
                data.ParameterOut.Add(new ParameterOutWrapper("@DES_CLAS", DbType.String, 100));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_CORO", DbType.String, 15));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_RGTO_ATIV", DbType.Int16, 2));

                dr = data.ExecuteParameterToDataSet("DB2IM.IMSJ5").Tables[0].Rows[0];

                classeProdutoFinanceiro = EntidadeFactory.getClasseProdutoFinanceiro(dr);

                return classeProdutoFinanceiro;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                classeProdutoFinanceiro = null;
                data.Dispose();
                data = null;
                dr = null;
            }

            return new ClasseProdutoFinanceiro();
        }

        public void AtualizarClasseProdutoFinanceiro(ClasseProdutoFinanceiro classeProduto)
        {
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_CLAS_PROD", classeProduto.CodigoClasseProduto, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_CLAS_PROD", classeProduto.NomeClasseProduto, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@DES_CLAS", classeProduto.DescricaoClasse, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CORO_WHERE", classeProduto.CodigoCorporativo, DbType.String));

                data.ParameterIn.Add(new ParameterInWrapper("@IND_RGTO_ATIV", 1, DbType.Int16));

                data.ExecuteNonQuery("DB2IM.IMSHT");
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }
        }

        public IList<ProdutoFinanceiroDerivado> ObterProdutosDerivadosPorProduto(int codigoProduto)
        {
            List<ProdutoFinanceiroDerivado> listasProdutosFinanceirosDerivados = new List<ProdutoFinanceiroDerivado>();

            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN", codigoProduto, DbType.Int32));

                DataSet ds = data.ExecuteDataSet("DB2IM.IMSJB");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        listasProdutosFinanceirosDerivados.Add(EntidadeFactory.getProdutoFinanceiroDerivado(linha));
                    }
                }
                return listasProdutosFinanceirosDerivados;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                listasProdutosFinanceirosDerivados = null;
                data.Dispose();
                data = null;
            }

            return new List<ProdutoFinanceiroDerivado>();
        }

        public IList<ProdutoFinanceiroDerivado> ObterProdutosDerivadosPorIndicadorRegistroAtivo(int indicadorRegistroAtivo)
        {
            List<ProdutoFinanceiroDerivado> listasProdutosFinanceirosDerivados = new List<ProdutoFinanceiroDerivado>();

            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@WIND_RGTO_ATIV", indicadorRegistroAtivo, DbType.Int32));

                DataSet ds = data.ExecuteDataSet("DB2IM.IM0SPC");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        listasProdutosFinanceirosDerivados.Add(EntidadeFactory.getProdutoFinanceiroDerivado(linha));
                    }
                }
                return listasProdutosFinanceirosDerivados;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                listasProdutosFinanceirosDerivados = null;
                data.Dispose();
                data = null;
            }

            return new List<ProdutoFinanceiroDerivado>();
        }

        public IList<ProdutoFinanceiroDerivado> ObterProdutosDerivadosPorCodigoGRNome(int codigoProdutoFinanceiroDerivado, string codigoProdutoFinanceiroGR, string nomeProdutoFinanceiroDerivado)
        {
            List<ProdutoFinanceiroDerivado> listasProdutosFinanceirosDerivados = new List<ProdutoFinanceiroDerivado>();

            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                //Parâmetros não obrigatórios
                data.ParameterIn.Add(new ParameterInWrapper("@WCOD_PROD_FINN_DRVD", codigoProdutoFinanceiroDerivado, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@WCOD_PROD_FINN_GR", codigoProdutoFinanceiroGR, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@WNOM_PROD_FINN_DRVD", nomeProdutoFinanceiroDerivado, DbType.String));

                DataSet ds = data.ExecuteDataSet("DB2IM.IM0S9F");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        listasProdutosFinanceirosDerivados.Add(EntidadeFactory.getProdutoFinanceiroDerivado(linha));
                    }
                }
                return listasProdutosFinanceirosDerivados;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                listasProdutosFinanceirosDerivados = null;
                data.Dispose();
                data = null;
            }

            return new List<ProdutoFinanceiroDerivado>();
        }

        public int ObterProdutoFinanceiroPorProdutoFinanceiroDerivado(int codigoProdutoFinanceiroDerivado)
        {
            int _codigoProdutosFinanceirosDerivado = 0;
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("COD_PROD_FINN_DRV", codigoProdutoFinanceiroDerivado, DbType.Int32));
                data.ParameterOut.Add(new ParameterOutWrapper("COD_PROD_FINN", DbType.Int16, 2));

                DataSet ds = data.ExecuteParameterToDataSet("DB2IM.IMS5A");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    _codigoProdutosFinanceirosDerivado = Convert.ToInt32(ds.Tables[0].Rows[0]["COD_PROD_FINN"].ToString());
                }

                return _codigoProdutosFinanceirosDerivado;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }

            return 0;
        }

        public IList<FamiliaProdutoFinanceiro> ObterFamiliasProdutoFinanceiro()
        {
            List<FamiliaProdutoFinanceiro> listasFamiliasProdutosFinanceiros = new List<FamiliaProdutoFinanceiro>();

            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                DataSet ds = data.ExecuteDataSet("DB2IM.IMSEH");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        listasFamiliasProdutosFinanceiros.Add(EntidadeFactory.getFamiliaProdutoFinanceiro(linha));
                    }
                }

                return listasFamiliasProdutosFinanceiros;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                listasFamiliasProdutosFinanceiros = null;
                data.Dispose();
                data = null;
            }

            return new List<FamiliaProdutoFinanceiro>();
        }

        public int CriarProdutoFinanceiro(ProdutoFinanceiro produtoFinanceiro)
        {
            int codigoproduto = 0;

            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_FAMI_PROD", produtoFinanceiro.CodigoFamiliaProduto, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_PROD_FIN", produtoFinanceiro.NomeProdutoFinanceiro, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_INRN_PROD_FIN", produtoFinanceiro.NomeInternoProdutoFinanceiro, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@DES_PROD_FIN", produtoFinanceiro.DescricaoProdutoFinanceiro, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CORO_PROD_FIN", produtoFinanceiro.CodigoCorporativoProdutoFinanceiro, DbType.String));

                codigoproduto = Convert.ToInt32(data.ExecuteScalar("DB2IM.IMSK8"));

                return codigoproduto;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }

            return codigoproduto = 0;
        }

        public int CriarProdutoFinanceiroDerivado(ProdutoFinanceiroDerivado produtoFinanceiroDerivado)
        {
            IDataAccessWrapper data = null;
            DataSet ds = null;
            int codigoproduto = 0;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN", produtoFinanceiroDerivado.CodigoProdutoFinanceiro, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_PROD_FINN_DRV", produtoFinanceiroDerivado.NomeProdutoFinanceiroDerivado, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN_GR", produtoFinanceiroDerivado.CodigoProdutoFinanceiroGR, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_PROD_DRVD_EXC", produtoFinanceiroDerivado.IndicadorProdutoDerivadoExcessao, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN_DRV", produtoFinanceiroDerivado.CodigoProdutoFinanceiroDerivado, DbType.Int32));
                ds = data.ExecuteParameterToDataSet("DB2IM.IM0SPS");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    codigoproduto = Convert.ToInt32(ds.Tables[0].Rows[0]["COD_PROD_FINN_DRV"].ToString());
                }

                return codigoproduto;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
                ds = null;
            }

            return codigoproduto = 0;
        }

        public void ExcluirProdutoFinanceiro(ProdutoFinanceiro produtoFinanceiro)
        {
            IDataAccessWrapper data = null;
            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN",
                                                           produtoFinanceiro.CodigoProdutoFinanceiro,
                                                            DbType.Int32));

                data.ExecuteNonQuery("DB2IM.IMSKR");
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }
        }

        public void ExcluirProdutosFinanceirosDerivados(IList<ProdutoFinanceiroDerivado> listaProdutosFinanceirosDerivados)
        {
            IDataAccessWrapper data = null;
            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                foreach (ProdutoFinanceiroDerivado item in listaProdutosFinanceirosDerivados)
                {
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN",
                                                               item.CodigoProdutoFinanceiro,
                                                                DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN_DR",
                                                               item.CodigoProdutoFinanceiroDerivado,
                                                                DbType.Int32));

                    data.ExecuteNonQuery("DB2IM.IMSKS");

                    data.ParameterIn.Clear();
                }

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }
        }

        public void ExcluirProdutoFinanceiroDerivado(ProdutoFinanceiroDerivado produtoFinanceiroDerivado)
        {
            IDataAccessWrapper data = null;
            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();


                data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN_DR",
                                                           produtoFinanceiroDerivado.CodigoProdutoFinanceiroDerivado,
                                                            DbType.Int32));

                data.ExecuteNonQuery("DB2IM.IMSKS");

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }
        }

        public void AtualizarProdutoFinanceiro(ProdutoFinanceiro produtoFinanceiro)
        {
            IDataAccessWrapper data = null;
            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN",
                                                            produtoFinanceiro.CodigoProdutoFinanceiro,
                                                            DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_FAMI_PROD",
                                                            produtoFinanceiro.CodigoFamiliaProduto,
                                                            DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_PROD_FINN",
                                                            produtoFinanceiro.NomeProdutoFinanceiro,
                                                            DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_INRN_PROD_FIN",
                                                            produtoFinanceiro.NomeInternoProdutoFinanceiro,
                                                            DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@DES_PROD_FINN",
                                                            produtoFinanceiro.DescricaoProdutoFinanceiro,
                                                            DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_CORO_PROD_FIN",
                                                            produtoFinanceiro.CodigoCorporativoProdutoFinanceiro,
                                                            DbType.String));

                data.ParameterIn.Add(new ParameterInWrapper("@IND_RGTO_ATIV", 1, DbType.Int16));

                data.ExecuteNonQuery("DB2IM.IMS44");
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }
        }

        public void AtualizarProdutosFinanceirosDerivados(IList<ProdutoFinanceiroDerivado> listaProdutosDerivados)
        {
            IDataAccessWrapper data = null;
            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                foreach (ProdutoFinanceiroDerivado item in listaProdutosDerivados)
                {

                    data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN", item.CodigoProdutoFinanceiro, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN_DR", item.CodigoProdutoFinanceiroDerivado, DbType.Int32));
                    data.ParameterIn.Add(new ParameterInWrapper("@NOM_PROD_FINN_DR", item.NomeProdutoFinanceiroDerivado, DbType.String));
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN_GR", item.CodigoProdutoFinanceiroGR, DbType.Int32));

                    data.ExecuteNonQuery("DB2IM.IMSNC");

                    data.ParameterIn.Clear();
                }

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }
        }

        public void CriarProdutosFinanceirosDerivados(IList<ProdutoFinanceiroDerivado> listaProdutosDerivados)
        {
            IDataAccessWrapper data = null;
            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                foreach (ProdutoFinanceiroDerivado item in listaProdutosDerivados)
                {
                    data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN",
                                                               item.CodigoProdutoFinanceiro,
                                                                DbType.Int32));

                    data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN_DR",
                                                                DBNull.Value,
                                                                 DbType.Int32));

                    data.ParameterIn.Add(new ParameterInWrapper("@NOM_PROD_FINN_DR",
                                                                item.NomeProdutoFinanceiroDerivado,
                                                                DbType.Int32));

                    data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN_GR",
                                                                DBNull.Value,
                                                                DbType.Int32));

                    data.ExecuteNonQuery("DB2IM.IMSK7");

                    data.ParameterIn.Clear();
                }

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }
        }

        public IList<ProdutoFinanceiroAlocacao> ObterProdutoFinanceiroAlocacaoPorProduto(int codigoProdutoFinanceiro)
        {
            List<ProdutoFinanceiroAlocacao> listaProdutoFinanceiroAlocacao = null;
            IDataAccessWrapper data = null;
            DataSet ds = null;
            try
            {
                listaProdutoFinanceiroAlocacao = new List<ProdutoFinanceiroAlocacao>();

                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN", codigoProdutoFinanceiro, DbType.Int32));

                ds = data.ExecuteDataSet("DB2IM.IMS61");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        ProdutoFinanceiroAlocacao produtoFinanceiroAlocacao = EntidadeFactory.getProdutoFinanceiroAlocacao(linha);
                        produtoFinanceiroAlocacao.CodigoProdutoFinanceiro = codigoProdutoFinanceiro;

                        listaProdutoFinanceiroAlocacao.Add(produtoFinanceiroAlocacao);
                    }
                }

                return listaProdutoFinanceiroAlocacao;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                listaProdutoFinanceiroAlocacao = null;
                ds = null;
                data.Dispose();
                data = null;
            }

            return new List<ProdutoFinanceiroAlocacao>();
        }

        public void AtualizarProdutoFinanceiroDerivado(ProdutoFinanceiroDerivado produtoFinanceiroDerivado)
        {
            IDataAccessWrapper data = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN", produtoFinanceiroDerivado.CodigoProdutoFinanceiro, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN_DRV", produtoFinanceiroDerivado.CodigoProdutoFinanceiroDerivado, DbType.Int32));
                data.ParameterIn.Add(new ParameterInWrapper("@NOM_PROD_FINN_DRV", produtoFinanceiroDerivado.NomeProdutoFinanceiroDerivado, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN_GR", produtoFinanceiroDerivado.CodigoProdutoFinanceiroGR, DbType.String));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_PROD_DRVD_EXC", produtoFinanceiroDerivado.IndicadorProdutoDerivadoExcessao, DbType.Int16));
                data.ParameterIn.Add(new ParameterInWrapper("@IND_RGTO_ATIV", produtoFinanceiroDerivado.IndicadorRegistroAtivo, DbType.Int16));

                data.ExecuteNonQuery("DB2IM.IMSNC");
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                data.Dispose();
                data = null;
            }

        }

        public ProdutoFinanceiroDerivado ObterProdutoFinanceiroDerivadoPorCodigoGR(string codigoProdutoFinanceiroGR)
        {
            ProdutoFinanceiroDerivado objRetorno = new ProdutoFinanceiroDerivado();
            IDataAccessWrapper data = null;
            DataSet ds = null;

            try
            {
                data = EnterpriseLibraryFactory.GetDataAccess();

                data.ParameterIn.Add(new ParameterInWrapper("@COD_PROD_FINN_GR", codigoProdutoFinanceiroGR, DbType.String));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_PROD_FINN", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@COD_PROD_FINN_DRV", DbType.Int32, 4));
                data.ParameterOut.Add(new ParameterOutWrapper("@NOM_PROD_FINN_DRV", DbType.String, 50));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_RGTO_ATIV", DbType.Int16, 2));
                data.ParameterOut.Add(new ParameterOutWrapper("@IND_PROD_DRVD_EXC", DbType.Int16, 2));

                ds = data.ExecuteParameterToDataSet("DB2IM.IMS1Q");

                if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
                {
                    foreach (DataRow linha in ds.Tables[0].Rows)
                    {
                        objRetorno = EntidadeFactory.getProdutoFinanceiroDerivadoIMS1Q(linha);
                    }
                }

                return objRetorno;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            finally
            {
                ds = null;
                objRetorno = null;
                data.Dispose();
                data = null;
            }

            return objRetorno;
        }

        public void AtualizarProdutoFinanceiroDerivadoCompleto(ProdutoFinanceiroDerivado produtoFinaceiroDerivado)
        {

        }

        #endregion
    }
    #endregion
}
#endregion